﻿<?xml version="1.0" encoding="utf-8"?>

<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->

<xs:schema id="IgniteConfigurationSection"
           targetNamespace="http://ignite.apache.org/schema/dotnet/IgniteConfigurationSection"
           elementFormDefault="qualified"
           xmlns="http://ignite.apache.org/schema/dotnet/IgniteConfigurationSection"
           xmlns:xs="http://www.w3.org/2001/XMLSchema">

    <xs:simpleType name="cacheMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Replicated" />
            <xs:enumeration value="Partitioned" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="cacheAtomicityMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Transactional" />
            <xs:enumeration value="Atomic" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="cacheRebalanceMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Sync" />
            <xs:enumeration value="Async" />
            <xs:enumeration value="None" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="cacheWriteSynchronizationMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="FullSync" />
            <xs:enumeration value="FullAsync" />
            <xs:enumeration value="PrimarySync" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="queryIndexType" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Sorted" />
            <xs:enumeration value="FullText" />
            <xs:enumeration value="Geospatial" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="transactionConcurrency" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Optimistic" />
            <xs:enumeration value="Pessimistic" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="transactionIsolation" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="ReadCommitted" />
            <xs:enumeration value="RepeatableRead" />
            <xs:enumeration value="Serializable" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="dataPageEvictionMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Disabled" />
            <xs:enumeration value="RandomLru" />
            <xs:enumeration value="Random2Lru" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="partitionLossPolicy" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="ReadOnlySafe" />
            <xs:enumeration value="ReadOnlyAll" />
            <xs:enumeration value="ReadWriteSafe" />
            <xs:enumeration value="ReadWriteAll" />
            <xs:enumeration value="Ignore" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="peerAssemblyLoadingMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Disabled" />
            <xs:enumeration value="CurrentAppDomain" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="walMode" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Defauls" />
            <xs:enumeration value="LogOnly" />
            <xs:enumeration value="Background" />
            <xs:enumeration value="None" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="checkpointWriteOrder" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Random" />
            <xs:enumeration value="Sequential" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="diskPageCompression" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Disabled" />
            <xs:enumeration value="SkipGarbage" />
            <xs:enumeration value="Zstd" />
            <xs:enumeration value="Lz4" />
            <xs:enumeration value="Snappy" />
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="asyncContinuationExecutor" final="restriction">
        <xs:restriction base="xs:string">
            <xs:enumeration value="ThreadPool" />
            <xs:enumeration value="UnsafeSynchronous" />
        </xs:restriction>
    </xs:simpleType>

    <xs:element name="igniteConfiguration">
        <xs:annotation>
            <xs:documentation>Ignite configuration root.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:all>
                <xs:element name="binaryConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Binary configuration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:all>
                            <xs:element name="typeConfigurations" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Type configurations.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element name="binaryTypeConfiguration" maxOccurs="unbounded">
                                            <xs:complexType>
                                                <xs:all>
                                                    <xs:element name="nameMapper" minOccurs="0">
                                                        <xs:annotation>
                                                            <xs:documentation>Name mapper for the given type.</xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:attribute name="type" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                    <xs:element name="idMapper" minOccurs="0">
                                                        <xs:annotation>
                                                            <xs:documentation>ID mapper for the given type. When it is necessary to resolve class (field) ID, then this property will be checked first. Otherwise, ID will be hash code of the class (field) simple name in lower case.</xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:attribute name="type" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                    <xs:element name="serializer" minOccurs="0">
                                                        <xs:annotation>
                                                            <xs:documentation>
                                                                Serializer for the given type. If not provided and class implements IBinarizable then its custom logic will be used. If not provided and class doesn't implement IBinarizable then all fields of the class except of those with [NotSerialized] attribute will be serialized with help of reflection.
                                                            </xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:attribute name="type" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                </xs:all>
                                                <xs:attribute name="typeName" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Fully qualified type name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="affinityKeyFieldName" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Affinity key field name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="keepDeserialized" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>
                                                            Keep deserialized flag. If set to non-null value, overrides default value set in BinaryTypeConfiguration.
                                                        </xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="isEnum" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>Whether this instance describes an enum type.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="types" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>
                                        Assembly-qualified type names (Type.AssemblyQualifiedName) for binarizable types. Shorthand for creating BinaryTypeConfiguration.
                                    </xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element maxOccurs="unbounded" name="string" type="xs:string" />
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="nameMapper" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Default name mapper.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="idMapper" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Default ID mapper.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="serializer" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Default serializer.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="timestampConverter" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Default date time converter.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:all>
                        <xs:attribute name="keepDeserialized" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Default keep deserialized flag.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="compactFooter" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Compact footer flag.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="forceTimestamp" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Force timestamp flag.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="cacheConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Cache configuration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="cacheConfiguration" maxOccurs="unbounded">
                                <xs:annotation>
                                    <xs:documentation>Cache configuration.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:all>
                                        <xs:element name="cacheStoreFactory" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Factory for underlying persistent storage for read-through and write-through operations.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:attribute name="type" type="xs:string" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="queryEntities" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Query entity configuration.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:sequence>
                                                    <xs:element name="queryEntity" maxOccurs="unbounded">
                                                        <xs:complexType>
                                                            <xs:all>
                                                                <xs:element name="fields" minOccurs="0">
                                                                    <xs:annotation>
                                                                        <xs:documentation>Query fields, a map from field name to Java type name. The order of fields defines the order of columns returned by the 'select *' queries.</xs:documentation>
                                                                    </xs:annotation>
                                                                    <xs:complexType>
                                                                        <xs:sequence>
                                                                            <xs:element name="queryField" maxOccurs="unbounded">
                                                                                <xs:complexType>
                                                                                    <xs:all>
                                                                                        <xs:element name="defaultValue" minOccurs="0">
                                                                                            <xs:annotation>
                                                                                                <xs:documentation>Default field value.</xs:documentation>
                                                                                            </xs:annotation>
                                                                                        </xs:element>
                                                                                    </xs:all>
                                                                                    <xs:attribute name="name" type="xs:string" use="required">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Cache name.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="fieldType" type="xs:string">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>.NET field type.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="fieldTypeName" type="xs:string">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Java field type name.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="isKeyField" type="xs:boolean">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Indicates whether this field belongs to the cache key.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="notNull" type="xs:boolean">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Indicates whether null value is allowed for the field.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="precision" type="xs:int">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Precision of field</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="scale" type="xs:int">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Scale of field</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                </xs:complexType>
                                                                            </xs:element>
                                                                        </xs:sequence>
                                                                    </xs:complexType>
                                                                </xs:element>
                                                                <xs:element name="aliases" minOccurs="0">
                                                                    <xs:annotation>
                                                                        <xs:documentation>Field name aliases: mapping from full name in dot notation to an alias that will be used as SQL column name. Example: {"parent.name" -> "parentName"}.</xs:documentation>
                                                                    </xs:annotation>
                                                                    <xs:complexType>
                                                                        <xs:sequence>
                                                                            <xs:element name="queryAlias" maxOccurs="unbounded">
                                                                                <xs:complexType>
                                                                                    <xs:attribute name="fullName" type="xs:string" use="required">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Full name of the query field.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="alias" type="xs:string" use="required">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Alias for the full name.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                </xs:complexType>
                                                                            </xs:element>
                                                                        </xs:sequence>
                                                                    </xs:complexType>
                                                                </xs:element>
                                                                <xs:element name="indexes" minOccurs="0">
                                                                    <xs:annotation>
                                                                        <xs:documentation>Query indexes.</xs:documentation>
                                                                    </xs:annotation>
                                                                    <xs:complexType>
                                                                        <xs:sequence>
                                                                            <xs:element name="queryIndex" maxOccurs="unbounded">
                                                                                <xs:complexType>
                                                                                    <xs:sequence>
                                                                                        <xs:element name="fields" minOccurs="1">
                                                                                            <xs:annotation>
                                                                                                <xs:documentation>Query fields, a map from field name to Java type name. The order of fields defines the order of columns returned by the 'select *' queries.</xs:documentation>
                                                                                            </xs:annotation>
                                                                                            <xs:complexType>
                                                                                                <xs:sequence>
                                                                                                    <xs:element name="queryIndexField" maxOccurs="unbounded">
                                                                                                        <xs:complexType>
                                                                                                            <xs:attribute name="name" type="xs:string" use="required">
                                                                                                                <xs:annotation>
                                                                                                                    <xs:documentation>Cache name.</xs:documentation>
                                                                                                                </xs:annotation>
                                                                                                            </xs:attribute>
                                                                                                            <xs:attribute name="isDescending" type="xs:boolean">
                                                                                                                <xs:annotation>
                                                                                                                    <xs:documentation>Whether this index is descending.</xs:documentation>
                                                                                                                </xs:annotation>
                                                                                                            </xs:attribute>
                                                                                                        </xs:complexType>
                                                                                                    </xs:element>
                                                                                                </xs:sequence>
                                                                                            </xs:complexType>
                                                                                        </xs:element>
                                                                                    </xs:sequence>
                                                                                    <xs:attribute name="name" type="xs:string">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Index name.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="indexType" type="queryIndexType">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Index type.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                    <xs:attribute name="inlineSize" type="xs:int">
                                                                                        <xs:annotation>
                                                                                            <xs:documentation>Index inline size in bytes. When enabled part of indexed value will be placed directly to index pages, thus minimizing data page accesses and increasing query performance.</xs:documentation>
                                                                                        </xs:annotation>
                                                                                    </xs:attribute>
                                                                                </xs:complexType>
                                                                            </xs:element>
                                                                        </xs:sequence>
                                                                    </xs:complexType>
                                                                </xs:element>
                                                            </xs:all>
                                                            <xs:attribute name="keyTypeName" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        Java key type name.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="keyType" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        .NET key type.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="valueTypeName" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        Java value type name.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="valueType" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        .NET value type.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="tableName" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        SQL table name. When not set, value type name is used.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="keyFieldName" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        Name of the field that denotes the key.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="valueFieldName" type="xs:string">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        Name of the field that denotes the value.
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                </xs:sequence>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="nearConfiguration" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Near cache configuration.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:all>
                                                    <xs:element name="evictionPolicy" minOccurs="0">
                                                        <xs:annotation>
                                                            <xs:documentation>Eviction policy. Null value means disabled evictions.</xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:attribute name="batchSize" type="xs:int">
                                                                <xs:annotation>
                                                                    <xs:documentation>
                                                                        Size of the eviction batch. Batch eviction is enabled only if maximum memory limit isn't set (MaxMemorySize == 0).
                                                                    </xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="maxSize" type="xs:int">
                                                                <xs:annotation>
                                                                    <xs:documentation>Maximum allowed cache size (entry count). 0 for unlimited.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="maxMemorySize" type="xs:int">
                                                                <xs:annotation>
                                                                    <xs:documentation>Maximum allowed cache size in bytes. 0 for unlimited.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="type" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                </xs:all>
                                                <xs:attribute name="nearStartSize" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Initial cache size for near cache which will be used to pre-create internal hash table after start.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="platformCacheConfiguration" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Platform cache configuration.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:attribute name="keyTypeName" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Fully-qualified platform type name of the cache key used for the local map. When not set, object-based map is used, which can reduce performance and increase allocations due to boxing.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="valueTypeName" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Fully-qualified platform type name of the cache value used for the local map. When not set, object-based map is used, which can reduce performance and increase allocations due to boxing.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="keepBinary" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>Whether platform cache should store keys and values in binary form.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="evictionPolicy" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Eviction policy. Null value means disabled evictions.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:attribute name="batchSize" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>
                                                            Size of the eviction batch. Batch eviction is enabled only if maximum memory limit isn't set (MaxMemorySize == 0).
                                                        </xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="maxSize" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Maximum allowed cache size (entry count). 0 for unlimited.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="maxMemorySize" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Maximum allowed cache size in bytes. 0 for unlimited.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="type" type="xs:string" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="affinityFunction" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Affinity function to provide mapping from keys to nodes.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:all>
                                                    <xs:element name="affinityBackupFilter" minOccurs="0">
                                                        <xs:annotation>
                                                            <xs:documentation>Optional backup filter. If provided, then backups will be selected from all nodes that pass this filter.</xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:all>
                                                                <xs:element name="attributeNames" minOccurs="0">
                                                                    <xs:annotation>
                                                                        <xs:documentation>Attribute names for the backup filter.</xs:documentation>
                                                                    </xs:annotation>
                                                                    <xs:complexType>
                                                                        <xs:sequence>
                                                                            <xs:element maxOccurs="unbounded" name="string" type="xs:string" />
                                                                        </xs:sequence>
                                                                    </xs:complexType>
                                                                </xs:element>
                                                            </xs:all>
                                                            <xs:attribute name="type" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                </xs:all>
                                                <xs:attribute name="partitions" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Number of partitions.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="excludeNeighbors" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>Whether to exclude same-host-neighbors from being backups of each other.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="type" type="xs:string" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="expiryPolicyFactory" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Factory for IExpiryPolicy to be used for all cache operations, unless ICache.WithExpiryPolicy is called. Default is null, which means no expiration.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:attribute name="type" type="xs:string" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="nodeFilter" minOccurs="0" maxOccurs="1">
                                          <xs:annotation>
                                            <xs:documentation>Node filter to match selected nodes. Only predefined AttributeNodeFilter is supported.</xs:documentation>
                                          </xs:annotation>
                                          <xs:complexType>
                                            <xs:attribute name="type" type="xs:string" use="required">
                                              <xs:annotation>
                                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                              </xs:annotation>
                                            </xs:attribute>
                                          </xs:complexType>
                                        </xs:element>
                                        <xs:element name="keyConfiguration" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Cache key configuration collection.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:sequence>
                                                    <xs:element name="cacheKeyConfiguration" maxOccurs="unbounded">
                                                        <xs:annotation>
                                                            <xs:documentation>Cache key configuration.</xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:attribute name="typeName" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Key type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                            <xs:attribute name="affinityKeyFieldName" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Affinity key field name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                </xs:sequence>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="pluginConfigurations" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>Cache plugin configurations.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:sequence>
                                                    <xs:element name="iCachePluginConfiguration" maxOccurs="unbounded">
                                                        <xs:annotation>
                                                            <xs:documentation>Cache plugin configuration.</xs:documentation>
                                                        </xs:annotation>
                                                        <xs:complexType>
                                                            <xs:attribute name="type" type="xs:string" use="required">
                                                                <xs:annotation>
                                                                    <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                                </xs:annotation>
                                                            </xs:attribute>
                                                        </xs:complexType>
                                                    </xs:element>
                                                </xs:sequence>
                                            </xs:complexType>
                                        </xs:element>
                                    </xs:all>
                                    <xs:attribute name="name" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Cache name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="cacheMode" type="cacheMode">
                                        <xs:annotation>
                                            <xs:documentation>Caching mode to use.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeSynchronizationMode" type="cacheWriteSynchronizationMode">
                                        <xs:annotation>
                                            <xs:documentation>Write synchronization mode. This mode controls whether the main caller should wait for update on other nodes to complete or not.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="loadPreviousValue" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Flag indicating whether value should be loaded from store if it is not in the cache.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="atomicityMode" type="cacheAtomicityMode">
                                        <xs:annotation>
                                            <xs:documentation>Cache atomicity mode.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="backups" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Number of nodes used to back up single partition for Partitioned cache.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="lockTimeout" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Default lock acquisition timeout.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="invalidate" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Invalidation flag. If true, values will be invalidated (nullified) upon commit in near cache.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceMode" type="cacheRebalanceMode">
                                        <xs:annotation>
                                            <xs:documentation>Cache rebalance mode.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceBatchSize" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Batch size (in number bytes) to be loaded within a single rebalance message. Rebalancing algorithm will split total data set on every node into multiple batches prior to sending data.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="maxConcurrentAsyncOperations" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Maximum number of allowed concurrent asynchronous operations, 0 for unlimited.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeBehindEnabled" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Flag indicating whether Ignite should use write-behind behaviour for the cache store.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeBehindFlushSize" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Maximum size of the write-behind cache. If cache size exceeds this value, all cached items are flushed to the cache store and write cache is cleared.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeBehindFlushThreadCount" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Number of threads that will perform cache flushing. Cache flushing is performed when cache size exceeds value defined by WriteBehindFlushSize, or flush interval defined by WriteBehindFlushFrequency is elapsed.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeBehindCoalescing" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Coalescing flag for write-behind cache store operations. Store operations (get or remove) with the same key are combined or coalesced to single, resulting operation to reduce pressure to underlying cache store.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeBehindBatchSize" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Maximum batch size for write-behind cache store operations. Store operations (get or remove) are combined in a batch of this size to be passed to ICacheStore.WriteAll or ICacheStore.DeleteAll methods.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceTimeout" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Rebalance timeout.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceDelay" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Delay upon a node joining or leaving topology (or crash) after which rebalancing should be started automatically. Rebalancing should be delayed if you plan to restart nodes after they leave topology, or if you plan to start multiple nodes at once or one after another and don't want to repartition and rebalance until all nodes are started.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceThrottle" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Time to wait between rebalance messages to avoid overloading of CPU or network. When rebalancing large data sets, the CPU or network can get over-consumed with rebalancing messages, which consecutively may slow down the application performance. This parameter helps tune the amount of time to wait between rebalance messages to make sure that rebalancing process does not have any negative performance impact. Note that application will continue to work properly while rebalancing is still in progress.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="offHeapMaxMemory" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Maximum amount of memory available to off-heap storage. Possible values are -1 means that off-heap storage is disabled. 0 means that Ignite will not limit off-heap storage (it's up to user to properly add and remove entries from cache to ensure that off-heap storage does not grow indefinitely. Any positive value specifies the limit of off-heap storage in bytes.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="longQueryWarningTimeout" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Timeout after which long query warning will be printed.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="sqlEscapeAll" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>If true all the SQL table and field names will be escaped with double quotes like ({ "tableName"."fieldsName"}). This enforces case sensitivity for field names and also allows having special characters in table and field names.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="readThrough" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether read-through should be enabled for cache operations.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeThrough" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether write-through should be enabled for cache operations.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="eagerTtl" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether expired cache entries will be eagerly removed from cache. When set to false, expired entries will be removed on next entry access.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="keepBinaryInStore" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Whether ICacheStore is working with binary objects instead of deserialized objects.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="readFromBackup" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether data can be read from backup.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="copyOnRead" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether copy of the value stored in cache should be created for cache operation implying return value.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="writeBehindFlushFrequency" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Frequency with which write-behind cache is flushed to the cache store. This value defines the maximum time interval between object insertion/deletion from the cache at the moment when corresponding operation is applied to the cache store.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="enableStatistics" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Value indicating whether statistics gathering is enabled on a cache. These statistics can be retrieved via ICache.GetMetrics().</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="dataRegionName" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Name of the DataRegionConfiguration for this cache.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="partitionLossPolicy" type="partitionLossPolicy">
                                        <xs:annotation>
                                            <xs:documentation>Partition loss policy defines how Ignite will react to a situation when all nodes for some partition leave the cluster.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="groupName" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Cache group name. Caches with the same group name share single underlying 'physical' cache (partition set), but are logically isolated.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="sqlIndexMaxInlineSize" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Maximum size of SQL inline index. Part of indexed value will be placed directly to index pages, thus minimizing data page accesses and increasing query performance.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="onheapCacheEnabled" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether on-heap cache is enabled for the off-heap based page memory.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="storeConcurrentLoadAllThreshold" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Threshold to use when multiple keys are being loaded from an underlying cache store.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceOrder" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Caches with bigger RebalanceOrder are rebalanced later than caches with smaller RebalanceOrder. 0 for unordered (immediate) rebalance.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="rebalanceBatchesPrefetchCount" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Rebalance batches prefetch count.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="maxQueryIteratorsCount" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Maximum number of active query iterators.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="queryDetailMetricsSize" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Size of the query detail metrics to be stored in memory.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="sqlSchema" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>SQL schema. Non-quoted identifiers are not case sensitive. Quoted identifiers are case sensitive. Quoted cache name is used by default.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="queryParallelism" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Desired query parallelism within a single node.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="encryptionEnabled" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Flag indicating whether cache encryption enabled.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="jvmOptions" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Collection of options passed to JVM on Ignite start.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element maxOccurs="unbounded" name="string" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="assemblies" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>List of additional .NET assemblies to load on Ignite start. Each item can be either fully qualified assembly name, path to assembly to DLL or path to a directory when assemblies reside.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element maxOccurs="unbounded" name="string" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="lifecycleHandlers" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Lifecycle event handlers.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element maxOccurs="unbounded" name="iLifecycleHandler">
                                <xs:complexType>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="encryptionSpi" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Encryption spi. Null for disabled encryption.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="masterKeyName" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Master key name</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="keySize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Encryption key size.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="keyStorePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Key store path.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="keyStorePassword" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Key store password.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="discoverySpi" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Discovery service provider. Null for default discovery.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="ipFinder" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>IP finder which defines how nodes will find each other on the network.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element name="endpoints" minOccurs="0">
                                            <xs:annotation>
                                                <xs:documentation>End points.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:sequence>
                                                    <xs:element maxOccurs="unbounded" name="string" type="xs:string" />
                                                </xs:sequence>
                                            </xs:complexType>
                                        </xs:element>
                                    </xs:sequence>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="localAddress" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Local host address for socket binding. Note that one node could have additional addresses beside the loopback one. This configuration parameter is optional.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="multicastGroup" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>IP address of the multicast group.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="multicastPort" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Port number which multicast messages are sent to.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="addressRequestAttempts" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Number of attempts to send multicast address request. IP finder re-sends request only in case if no reply for previous request is received.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="responseTimeout" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Response timeout.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="timeToLive" type="xs:byte">
                                        <xs:annotation>
                                            <xs:documentation>Time to live for multicast packets sent out on this IP finder in order to control the scope of the multicast.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                        <xs:attribute name="socketTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Socket timeout.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="ackTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Timeout for receiving acknowledgement for sent message.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="maxAckTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Maximum timeout for receiving acknowledgement for sent message.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="networkTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Network timeout.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="joinTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Join timeout.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="clientReconnectDisabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Whether client does not try to reconnect after server detected client node failure.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="forceServerMode" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>
                                    Whether TcpDiscoveryspi is started in server mode regardless of IgniteConfiguration.ClientMode setting.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="ipFinderCleanFrequency" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>IP finder clean frequency.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="localAddress" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Local host address for socket binding. Note that one node could have additional addresses beside the loopback one. This configuration parameter is optional.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="localPort" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Local port for socket binding.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="localPortRange" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>
                                    Local port range for local host ports (value must greater than or equal to <tt>0</tt>). If provided local port LocalPort is occupied, implementation will try to increment the port number for as long as it is less than initial value plus this range.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="reconnectCount" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum number of reconnect attempts used when establishing connection with remote nodes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="statisticsPrintFrequency" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>
                                    Statistics print frequency. TimeSpan.Zero for no statistics.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="threadPriority" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Sets thread priority, 1 (lowest) to 10 (highest). All threads within SPI will be started with it.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="topologyHistorySize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of topology snapshots history.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="communicationSpi" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Communication service provider. Null for default communication.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="ackSendThreshold" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of received messages per connection to node after which acknowledgment message is sent.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="connectTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Connect timeout used when establishing connection with remote nodes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="directBuffer" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Whether to allocate direct (ByteBuffer.allocateDirect) or heap (ByteBuffer.allocate) buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="directSendBuffer" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Value indicating whether to allocate direct (ByteBuffer.allocateDirect) or heap (ByteBuffer.allocate) send buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="idleConnectionTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Sets maximum idle connection timeout upon which a connection to client will be closed.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="localAddress" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Local host address for socket binding. Note that one node could have additional addresses beside the loopback one. This configuration parameter is optional.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="localPort" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Local port for socket binding.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="localPortRange" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>
                                    Local port range for local host ports (value must greater than or equal to 0). If provided local port LocalPort is occupied, implementation will try to increment the port number for as long as it is less than initial value plus this range.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="maxConnectTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Maximum connect timeout. If handshake is not established within connect timeout, then SPI tries to repeat handshake procedure with increased connect timeout. Connect timeout can grow till maximum timeout value, if maximum timeout value is reached then the handshake is considered as failed.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="messageQueueLimit" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Message queue limit for incoming and outgoing messages.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="reconnectCount" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum number of reconnect attempts used when establishing connection with remote nodes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="selectorsCount" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Count of selectors to be used in TCP server.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="slowClientQueueLimit" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Slow client queue limit.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="socketReceiveBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the socket receive buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="socketSendBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the socket send buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="tcpNoDelay" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>
                                    Value for TCP_NODELAY socket option. Each socket will be opened using provided value.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="unacknowledgedMessagesBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum number of stored unacknowledged messages per connection to node. If number of unacknowledged messages exceeds this number then connection to node is closed and reconnect is attempted.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="includedEventTypes" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>
                            A set of event types to be recorded by Ignite.
                        </xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element maxOccurs="unbounded" name="int" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="userAttributes" minOccurs="0">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element maxOccurs="unbounded" name="pair"  />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="atomicConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Atomic data structures configuration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="cacheMode" type="cacheMode">
                            <xs:annotation>
                                <xs:documentation>Caching mode to use.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="backups" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>
                                    Number of nodes used to back up single partition for Partitioned cache.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="atomicSequenceReserveSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>
                                    The default number of sequence values reserved for IAtomicSequence instances. After a certain number has been reserved, consequent increments of sequence will happen locally, without communication with other nodes, until the next reservation has to be made.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="transactionConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Transaction configuration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="defaultTransactionConcurrency" type="transactionConcurrency">
                            <xs:annotation>
                                <xs:documentation>Cache transaction concurrency to use when one is not explicitly specified.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="defaultTransactionIsolation" type="transactionIsolation">
                            <xs:annotation>
                                <xs:documentation>Cache transaction isolation to use when one is not explicitly specified.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="defaultTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>
                                    Cache transaction timeout to use when one is not explicitly specified. TimeSpan.Zero for infinite timeout.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="pessimisticTransactionLogSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>
                                    Size of pessimistic transactions log stored on node in order to recover transaction commit if originating node has left grid before it has sent all messages to transaction nodes. 0 for unlimited.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="pessimisticTransactionLogLinger" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Delay after which pessimistic recovery entries will be cleaned up for failed node.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="defaultTimeoutOnPartitionMapExchange" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>
                                    Transaction timeout for partition map synchronization. TimeSpan.Zero for infinite timeout.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="logger" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>The logger. If no logger is set, logging is delegated to Java, which uses the logger defined in Spring XML (if present) or logs to console otherwise.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="eventStorageSpi" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Event storage space SPI.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="expirationTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Expiration timeout for stored events. Negative for unlimited.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="maxEventCount" type="xs:long">
                            <xs:annotation>
                                <xs:documentation>Maximum event count to store.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="memoryConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Page memory configuration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="memoryPolicies" minOccurs="0" maxOccurs="1">
                                <xs:annotation>
                                    <xs:documentation>Memory policies.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element name="memoryPolicyConfiguration" minOccurs="0" maxOccurs="unbounded">
                                            <xs:complexType>
                                                <xs:attribute name="emptyPagesPoolSize" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Minimal number of empty pages to be present in reuse lists for this memory policy.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="evictionThreshold" type="xs:double">
                                                    <xs:annotation>
                                                        <xs:documentation>Threshold for memory pages eviction initiation. For instance, if the threshold is 0.9 it means that the page memory will start the eviction only after 90% of the memory region (defined by this policy) is occupied.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="name" type="xs:string" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Memory policy name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="pageEvictionMode" type="dataPageEvictionMode">
                                                    <xs:annotation>
                                                        <xs:documentation>Page eviction mode.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="initialSize" type="xs:long">
                                                    <xs:annotation>
                                                        <xs:documentation>Initial memory region size defined by this memory policy.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="maxSize" type="xs:long">
                                                    <xs:annotation>
                                                        <xs:documentation>Maximum memory region size defined by this memory policy.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="swapFilePath" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Path to the memory-mapped file the memory region defined by this memory policy will be mapped to.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="metricsEnabled" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>Enable memory metrics.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="subIntervals" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Number of sub intervals to split RateTimeInterval into.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="rateTimeInterval" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Rate time interval for AllocationRate and EvictionRate monitoring.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                        <xs:attribute name="concurrencyLevel" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of concurrent segments in Ignite internal page mapping tables.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="defaultMemoryPolicyName" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Name of the default memory policy in MemoryPolicies.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="pageSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the memory page.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="systemCacheInitialSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Initial size of a memory chunk reserved for system cache needs.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="systemCacheMaxSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum size of a memory chunk reserved for system cache needs.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="sqlConnectorConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>SQL connector configuration (JDBC and ODBC).</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="port" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Connector port.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="host" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Connector host.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="portRange" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Connector port range.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="socketSendBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the socket send buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="socketReceiveBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the socket receive buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="tcpNoDelay" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>TCP_NODELAY socket option.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="maxOpenCursorsPerConnection" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum open cursors per connection.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="threadPoolSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>SQL connector thread pool size.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="clientConnectorConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Client connector configuration (JDBC, ODBC, thin clients).</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:all>
                            <xs:element name="thinClientConfiguration" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Thin client specific configuration.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="maxActiveTxPerConnection" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Active transactions count per connection limit.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="maxActiveComputeTasksPerConnection" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Active compute tasks per connection limit. Or 0 if compute grid functionality is disabled for thin clients.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="sendServerExceptionStackTraceToClient" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Whether to send full server exception stack trace to clients.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:all>
                        <xs:attribute name="port" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Connector port.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="host" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Connector host.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="portRange" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Connector port range.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="socketSendBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the socket send buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="socketReceiveBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the socket receive buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="tcpNoDelay" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>TCP_NODELAY socket option.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="maxOpenCursorsPerConnection" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum open cursors per connection.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="threadPoolSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>SQL connector thread pool size.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="idleTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Idle timeout for client connections on the server side. If no packets come within idle timeout, the connection is closed by the server. Zero or negative for no timeout.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="handshakeTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Handshake timeout for client connections on the server side. If no successful handshake is performed within this timeout upon successful establishment of TCP connection, the connection is closed by the server. Zero or negative for no timeout.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="thinClientEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Enables thin client connector.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="jdbcEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Enables JDBC connector.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="odbcEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Enables ODBC connector.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="persistentStoreConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Persistent store configuration. Obsolete, use DataStorageConfiguration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="persistentStorePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path where data and indexes will be persisted.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointingFrequency" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Checkpointing frequency which is a minimal interval when the dirty pages will be written to the Persistent Store.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointingPageBufferSize" type="xs:long">
                            <xs:annotation>
                                <xs:documentation>Size of the checkpointing page buffer.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointingThreads" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of threads for checkpointing.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="lockWaitTime" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Persistent manager file lock wait time.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walHistorySize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of checkpoints to store in WAL (Write Ahead Log) history.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walSegments" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of WAL (Write Ahead Log) segments to work with.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walSegmentSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the WAL (Write Ahead Log) segment.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walStorePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path to the directory where WAL (Write Ahead Log) is stored.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walArchivePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path to the directory where WAL (Write Ahead Log) archive is stored.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walMode" type="walMode">
                            <xs:annotation>
                                <xs:documentation>WAL (Write Ahead Log) mode.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="tlbSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the TLB (Thread-Local Buffer), in bytes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walFlushFrequency" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>WAL (Write Ahead Log) flush frequency.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walFsyncDelayNanos" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>WAL (Write Ahead Log) fsync (disk sync) delay, in nanoseconds.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walRecordIteratorBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the WAL (Write Ahead Log) record iterator buffer, in bytes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="alwaysWriteFullPages" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Whether full pages should always be written.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="metricsEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Enable persistent store metrics.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="subIntervals" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of sub intervals to split RateTimeInterval into.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="rateTimeInterval" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Rate time interval.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointWriteOrder" type="checkpointWriteOrder">
                            <xs:annotation>
                                <xs:documentation>Checkpoint page write order on disk.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="writeThrottlingEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Threads that generate dirty pages too fast during ongoing checkpoint will be throttled.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="dataStorageConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Data storage configuration.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:all>
                            <xs:element name="defaultDataRegionConfiguration">
                                <xs:annotation>
                                    <xs:documentation>Default data region configuration.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="emptyPagesPoolSize" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Minimal number of empty pages to be present in reuse lists for this memory policy.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="evictionThreshold" type="xs:double">
                                        <xs:annotation>
                                            <xs:documentation>Threshold for memory pages eviction initiation. For instance, if the threshold is 0.9 it means that the page memory will start the eviction only after 90% of the memory region (defined by this policy) is occupied.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="name" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Data region name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="pageEvictionMode" type="dataPageEvictionMode">
                                        <xs:annotation>
                                            <xs:documentation>Page eviction mode.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="initialSize" type="xs:long">
                                        <xs:annotation>
                                            <xs:documentation>Initial data region size.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="maxSize" type="xs:long">
                                        <xs:annotation>
                                            <xs:documentation>Maximum data region size.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="swapPath" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Path to the directory for memory-mapped files.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="metricsEnabled" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Enable memory metrics.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="metricsSubIntervalCount" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Number of sub intervals to split RateTimeInterval into.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="metricsRateTimeInterval" type="xs:string">
                                        <xs:annotation>
                                            <xs:documentation>Rate time interval for AllocationRate and EvictionRate monitoring.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="persistenceEnabled" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>Enable disk persistence for this region.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="checkpointPageBufferSize" type="xs:long">
                                        <xs:annotation>
                                            <xs:documentation>Size of the checkpointing page buffer.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="lazyMemoryAllocation" type="xs:boolean">
                                        <xs:annotation>
                                            <xs:documentation>
                                                Enable lazy memory allocation.
                                            </xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="dataRegionConfigurations">
                                <xs:annotation>
                                    <xs:documentation>Data region configurations.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element minOccurs="1" maxOccurs="unbounded" name="dataRegionConfiguration">
                                            <xs:annotation>
                                                <xs:documentation>Data region configuration.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:attribute name="emptyPagesPoolSize" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Minimal number of empty pages to be present in reuse lists for this memory policy.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="evictionThreshold" type="xs:double">
                                                    <xs:annotation>
                                                        <xs:documentation>Threshold for memory pages eviction initiation. For instance, if the threshold is 0.9 it means that the page memory will start the eviction only after 90% of the memory region (defined by this policy) is occupied.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="name" type="xs:string" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Data region name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="pageEvictionMode" type="dataPageEvictionMode">
                                                    <xs:annotation>
                                                        <xs:documentation>Page eviction mode.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="initialSize" type="xs:long">
                                                    <xs:annotation>
                                                        <xs:documentation>Initial data region size.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="maxSize" type="xs:long">
                                                    <xs:annotation>
                                                        <xs:documentation>Maximum data region size.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="swapPath" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Path to the directory for memory-mapped files.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="metricsEnabled" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>Enable memory metrics.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="metricsSubIntervalCount" type="xs:int">
                                                    <xs:annotation>
                                                        <xs:documentation>Number of sub intervals to split RateTimeInterval into.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="metricsRateTimeInterval" type="xs:string">
                                                    <xs:annotation>
                                                        <xs:documentation>Rate time interval for AllocationRate and EvictionRate monitoring.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="persistenceEnabled" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>Enable disk persistence for this region.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="checkpointPageBufferSize" type="xs:long">
                                                    <xs:annotation>
                                                        <xs:documentation>Size of the checkpointing page buffer.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                                <xs:attribute name="lazyMemoryAllocation" type="xs:boolean">
                                                    <xs:annotation>
                                                        <xs:documentation>
                                                            Enable lazy memory allocation.
                                                        </xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                            <xs:element name="systemDataRegionConfiguration">
                                <xs:annotation>
                                    <xs:documentation>System data region configuration.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="initialSize" type="xs:long">
                                        <xs:annotation>
                                            <xs:documentation>Initial size of system data region.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="maxSize" type="xs:long">
                                        <xs:annotation>
                                            <xs:documentation>Maximum size of system data region.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:all>
                        <xs:attribute name="storagePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path where data and indexes will be persisted.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointFrequency" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Checkpointing frequency which is a minimal interval when the dirty pages will be written to the Persistent Store.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointThreads" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of threads for checkpointing.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="lockWaitTime" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Persistent manager file lock wait time.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walHistorySize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of checkpoints to store in WAL (Write Ahead Log) history.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walSegments" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of WAL (Write Ahead Log) segments to work with.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walSegmentSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the WAL (Write Ahead Log) segment.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walPath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path to the directory where WAL (Write Ahead Log) is stored.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walArchivePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path to the directory where WAL (Write Ahead Log) archive is stored.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walMode" type="walMode">
                            <xs:annotation>
                                <xs:documentation>WAL (Write Ahead Log) mode.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walThreadLocalBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the TLB (Thread-Local Buffer), in bytes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walFlushFrequency" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>WAL (Write Ahead Log) flush frequency.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walFsyncDelayNanos" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>WAL (Write Ahead Log) fsync (disk sync) delay, in nanoseconds.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walRecordIteratorBufferSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the WAL (Write Ahead Log) record iterator buffer, in bytes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="alwaysWriteFullPages" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Whether full pages should always be written.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="metricsEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Enable persistent store metrics.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="metricsSubIntervalCount" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of sub intervals to split RateTimeInterval into.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="metricsRateTimeInterval" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Rate time interval.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointWriteOrder" type="checkpointWriteOrder">
                            <xs:annotation>
                                <xs:documentation>Checkpoint page write order on disk.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="writeThrottlingEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Threads that generate dirty pages too fast during ongoing checkpoint will be throttled.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walCompactionEnabled" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>If true, system will filter and compress WAL archive in background. Compressed WAL archive gets automatically decompressed on demand.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="maxWalArchiveSize" type="xs:long">
                            <xs:annotation>
                                <xs:documentation>Maximum size of wal archive folder, in bytes.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="pageSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Size of the memory page.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="systemRegionInitialSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Initial size of a memory region reserved for system needs. Obsolete, use systemDataRegionConfiguration</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="systemRegionMaxSize" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Maximum size of a memory region reserved for system needs. Obsolete, use systemDataRegionConfiguration</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="concurrencyLevel" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Number of concurrent segments in Ignite internal page mapping tables.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walAutoArchiveAfterInactivity" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Inactivity time after which to run WAL segment auto archiving.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walForceArchiveTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Time interval (in milliseconds) for force archiving of incompletely WAL segment.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="checkpointReadLockTimeout" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>
                                    Timeout for checkpoint read lock acquisition.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walPageCompression" type="diskPageCompression">
                            <xs:annotation>
                                <xs:documentation>Compression algorithm for WAL page snapshot records.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="walPageCompressionLevel" type="xs:int">
                            <xs:annotation>
                                <xs:documentation>Compression level for WAL page snapshot records.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="sslContextFactory" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Factory for SSL Context.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:attribute name="keyAlgorithm" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Key manager algorithm that will be used to create a key manager.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="keyStoreType" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Key store type used for context creation.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="keyStoreFilePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path to key store file.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="keyStorePassword" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Key store password.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="protocol" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Protocol for secure transport.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="trustStoreType" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Trust store type used for context creation.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="trustStoreFilePath" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Path to trust store file.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="trustStorePassword" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Trust store password.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                              <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="pluginConfigurations" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Plugin configurations.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="iPluginConfiguration" maxOccurs="unbounded">
                                <xs:annotation>
                                    <xs:documentation>Plugin configuration.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute name="type" type="xs:string" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute name="pluginConfigurationClosureFactoryId" type="xs:int">
                                        <xs:annotation>
                                            <xs:documentation>Id to locate PlatformPluginConfigurationClosureFactory on Java side.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="consistentId" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Consistent globally unique node identifier which survives node restarts.</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element name="localEventListeners" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Pre-configured local event listeners.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="localEventListener" maxOccurs="unbounded" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Listener holder.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element name="eventTypes">
                                            <xs:annotation>
                                                <xs:documentation>Event types to listen for.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:sequence>
                                                    <xs:element type="xs:string" name="int" maxOccurs="unbounded" minOccurs="1"/>
                                                </xs:sequence>
                                            </xs:complexType>
                                        </xs:element>
                                        <xs:element name="listener">
                                            <xs:annotation>
                                                <xs:documentation>Listener implementation.</xs:documentation>
                                            </xs:annotation>
                                            <xs:complexType>
                                                <xs:attribute type="xs:string" name="type" use="required">
                                                    <xs:annotation>
                                                        <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                                    </xs:annotation>
                                                </xs:attribute>
                                            </xs:complexType>
                                        </xs:element>
                                    </xs:sequence>
                                    <xs:attribute type="xs:string" name="type" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Assembly-qualified type name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="failureHandler" minOccurs="0">
                    <xs:complexType>
                        <xs:attribute name="type" type="xs:string" use="required">
                            <xs:annotation>
                                <xs:documentation>Assembly-qualified type name.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="tryStop" type="xs:boolean" default="false">
                            <xs:annotation>
                                <xs:documentation>Try stop before halt node parameter, use only for StopNodeOrHaltFailureHandler.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                        <xs:attribute name="timeout" type="xs:string" default="0:0:0">
                            <xs:annotation>
                                <xs:documentation>Timeout for node stop, use only for StopNodeOrHaltFailureHandler.</xs:documentation>
                            </xs:annotation>
                        </xs:attribute>
                    </xs:complexType>
                </xs:element>
                <xs:element name="sqlSchemas" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>SQL schemas to be created on node startup. Schemas are created on local node only and are not propagated.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element maxOccurs="unbounded" name="string" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="executorConfiguration" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Custom executor configuration for compute tasks.</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="executorConfiguration" maxOccurs="unbounded" minOccurs="0">
                                <xs:annotation>
                                    <xs:documentation>Thread pool configuration for compute tasks.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                    <xs:attribute type="xs:string" name="name" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Thread pool name.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                    <xs:attribute type="xs:int" name="size" use="required">
                                        <xs:annotation>
                                            <xs:documentation>Thread pool size.</xs:documentation>
                                        </xs:annotation>
                                    </xs:attribute>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:all>
            <xs:attribute name="igniteInstanceName" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Local Ignite instance name to be used with Ignition.GetIgnite.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="autoGenerateIgniteInstanceName" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Generate unique igniteInstanceName automatically.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="jvmDllPath" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Path jvm.dll file. If not set, it's location will be determined using JAVA_HOME environment variable. If path is neither set nor determined automatically, an exception will be thrown.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="igniteHome" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Path to Ignite home. If not set environment variable IGNITE_HOME will be used.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="jvmClasspath" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Classpath used by JVM on Ignite start.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="suppressWarnings" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Whether to suppress warnings.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="jvmInitialMemoryMb" type="xs:int">
                <xs:annotation>
                    <xs:documentation>
                        Initial amount of memory in megabytes given to JVM. Maps to -Xms Java option. -1 maps to JVM defaults.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="jvmMaxMemoryMb" type="xs:int">
                <xs:annotation>
                    <xs:documentation>
                        Maximum amount of memory in megabytes given to JVM. Maps to -Xmx Java option. -1 maps to JVM defaults.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="clientMode" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>
                        Whether node should start in client mode. Client node cannot hold data in the caches.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="metricsExpireTime" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Time after which a certain metric value is considered expired.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="metricsHistorySize" type="xs:int">
                <xs:annotation>
                    <xs:documentation>
                        Number of metrics kept in history to compute totals and averages.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="metricsLogFrequency" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Frequency of metrics log print out.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="metricsUpdateFrequency" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Metrics update frequency.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="networkSendRetryCount" type="xs:int">
                <xs:annotation>
                    <xs:documentation>
                        Network send retry count.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="networkSendRetryDelay" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Network send retry delay.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="networkTimeout" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Network timeout.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="workDirectory" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Work directory. If not provided, a folder under IgniteHome will be used.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="localhost" type="xs:string">
                <xs:annotation>
                    <xs:documentation>System-wide local address or host for all Ignite components to bind to. If provided it will override all default local bind settings within Ignite.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="springConfigUrl" type="xs:string">
                <xs:annotation>
                    <xs:documentation>URL to Spring configuration file.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="isLateAffinityAssignment" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>
                        Whether late affinity assignment mode should be used.
                        On each topology change, for each started cache, partition-to-node mapping is
                        calculated using AffinityFunction for cache. When late
                        affinity assignment mode is disabled then new affinity mapping is applied immediately.
                        With late affinity assignment mode, if primary node was changed for some partition, but data for this
                        partition is not rebalanced yet on this node, then current primary is not changed and new primary
                        is temporary assigned as backup. This nodes becomes primary only when rebalancing for all assigned primary
                        partitions is finished. This mode can show better performance for cache operations, since when cache
                        primary node executes some operation and data is not rebalanced yet, then it sends additional message
                        to force rebalancing from other nodes.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="failureDetectionTimeout" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Failure detection timeout used by discovery and communication subsystems.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="systemWorkerBlockedTimeout" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Timeout for blocked system workers detection.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="clientFailureDetectionTimeout" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Failure detection timeout used by discovery and communication subsystems for client nodes.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="longQueryWarningTimeout" type="xs:string">
                <xs:annotation>
                    <xs:documentation>
                        Timeout after which long query warning will be printed.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="peerAssemblyLoadingMode" type="peerAssemblyLoadingMode">
                <xs:annotation>
                    <xs:documentation>Indicates whether user assemblies should be loaded on remote nodes automatically.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="publicThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the public thread pool, which processes compute jobs and user messages.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="stripedThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the striped thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="serviceThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the service thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="systemThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the system thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="asyncCallbackThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the async callback thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="managementThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the management thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="dataStreamerThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the data streamer thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="utilityCacheThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the utility cache thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="queryThreadPoolSize" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Size of the query thread pool.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="isActiveOnStart" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Whether grid should be active on start.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="authenticationEnabled" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Whether user authentication is enabled for the cluster.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="sqlQueryHistorySize" type="xs:int">
                <xs:annotation>
                    <xs:documentation>Number of SQL query history elements to keep in memory.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="javaPeerClassLoadingEnabled" type="xs:boolean">
              <xs:annotation>
                <xs:documentation>Indicates whether Java peer class loading is enabled.</xs:documentation>
              </xs:annotation>
            </xs:attribute>
            <xs:attribute name="clientConnectorConfigurationEnabled" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Whether client connector should be enabled (allow thin clients, ODBC and JDBC drivers to work with Ignite).</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="redirectJavaConsoleOutput" type="xs:boolean">
              <xs:annotation>
                <xs:documentation>Whether Java console output should be redirected to Console.Out and Console.Error.</xs:documentation>
              </xs:annotation>
            </xs:attribute>
            <xs:attribute name="asyncContinuationExecutor" type="asyncContinuationExecutor">
              <xs:annotation>
                <xs:documentation>Async continuation behavior.</xs:documentation>
              </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
</xs:schema>

